#ifndef SCREENSHOTWIDGET_H
#define SCREENSHOTWIDGET_H

#include <QWidget>
#include <QPixmap>
#include <QPainter>
#include <QMouseEvent>
#include <QKeyEvent>
#include <QApplication>
#include <QScreen>
#include <QPoint>
#include <QRect>
#include <QColor>
#include <QPen>
#include <QBrush>
#include <QPushButton>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QStack>
#include <QList>
#include <QFont>
#include <QTextEdit>
#include <QPolygonF>
#include <QPointF>
#include <cmath>
#include "view_global.h"

/**
 * @brief 绘图工具类型枚举
 */
enum class DrawTool {
    None = 0,       // 无工具（选择模式）
    Rectangle,      // 矩形
    Circle,         // 圆形
    Arrow,          // 箭头
    Pen,            // 画笔
    Mosaic,         // 马赛克
    Text            // 文字
};

/**
 * @brief 绘图元素基类
 */
struct DrawElement {
    DrawTool tool;
    QColor color;
    int penWidth;
    
    DrawElement(DrawTool t, const QColor& c, int w) : tool(t), color(c), penWidth(w) {}
    virtual ~DrawElement() {}
    virtual void draw(QPainter& painter) = 0;
    virtual QRect boundingRect() const = 0;
};

/**
 * @brief 矩形元素
 */
struct RectangleElement : public DrawElement {
    QRect rect;
    bool filled;
    
    RectangleElement(const QRect& r, const QColor& c, int w, bool f = false)
        : DrawElement(DrawTool::Rectangle, c, w), rect(r), filled(f) {}
    
    void draw(QPainter& painter) override {
        painter.setPen(QPen(color, penWidth));
        if (filled) {
            painter.setBrush(QBrush(color));
        } else {
            painter.setBrush(Qt::NoBrush);
        }
        painter.drawRect(rect);
    }
    
    QRect boundingRect() const override { return rect; }
};

/**
 * @brief 圆形元素
 */
struct CircleElement : public DrawElement {
    QRect rect;
    bool filled;
    
    CircleElement(const QRect& r, const QColor& c, int w, bool f = false)
        : DrawElement(DrawTool::Circle, c, w), rect(r), filled(f) {}
    
    void draw(QPainter& painter) override {
        painter.setPen(QPen(color, penWidth));
        if (filled) {
            painter.setBrush(QBrush(color));
        } else {
            painter.setBrush(Qt::NoBrush);
        }
        painter.drawEllipse(rect);
    }
    
    QRect boundingRect() const override { return rect; }
};

/**
 * @brief 箭头元素
 */
struct ArrowElement : public DrawElement {
    QPoint startPoint;
    QPoint endPoint;
    
    ArrowElement(const QPoint& start, const QPoint& end, const QColor& c, int w)
        : DrawElement(DrawTool::Arrow, c, w), startPoint(start), endPoint(end) {}
    
    void draw(QPainter& painter) override {
        painter.setPen(QPen(color, penWidth));
        painter.setBrush(QBrush(color));
        
        // 绘制箭头线
        painter.drawLine(startPoint, endPoint);
        
        // 绘制箭头头部
        QPointF direction = endPoint - startPoint;
        double length = sqrt(direction.x() * direction.x() + direction.y() * direction.y());
        if (length > 0) {
            direction /= length;
            QPointF perp(-direction.y(), direction.x());
            
            QPointF arrowP1 = endPoint - QPointF(direction * 15 - perp * 8);
            QPointF arrowP2 = endPoint - QPointF(direction * 15 + perp * 8);
            
            QPolygonF arrowHead;
            arrowHead << endPoint << arrowP1 << arrowP2;
            painter.drawPolygon(arrowHead);
        }
    }
    
    QRect boundingRect() const override {
        return QRect(startPoint, endPoint).normalized().adjusted(-20, -20, 20, 20);
    }
};

/**
 * @brief 画笔元素（自由绘制）
 */
struct PenElement : public DrawElement {
    QList<QPoint> points;
    
    PenElement(const QColor& c, int w) : DrawElement(DrawTool::Pen, c, w) {}
    
    void addPoint(const QPoint& point) { points.append(point); }
    
    void draw(QPainter& painter) override {
        if (points.size() < 2) return;
        
        painter.setPen(QPen(color, penWidth, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
        painter.setBrush(Qt::NoBrush);
        
        for (int i = 1; i < points.size(); ++i) {
            painter.drawLine(points[i-1], points[i]);
        }
    }
    
    QRect boundingRect() const override {
        if (points.isEmpty()) return QRect();
        int minX = points[0].x(), maxX = points[0].x();
        int minY = points[0].y(), maxY = points[0].y();
        for (const QPoint& p : points) {
            minX = qMin(minX, p.x());
            maxX = qMax(maxX, p.x());
            minY = qMin(minY, p.y());
            maxY = qMax(maxY, p.y());
        }
        return QRect(minX, minY, maxX - minX, maxY - minY).adjusted(-penWidth, -penWidth, penWidth, penWidth);
    }
};

/**
 * @brief 马赛克元素
 */
struct MosaicElement : public DrawElement {
    QRect rect;
    int blockSize;
    
    MosaicElement(const QRect& r, const QColor& c, int w, int bs = 10)
        : DrawElement(DrawTool::Mosaic, c, w), rect(r), blockSize(bs) {}
    
    void draw(QPainter& painter) override {
        // 马赛克效果：将区域分成小块，每个块填充平均颜色
        // 简化实现：使用半透明矩形覆盖
        painter.setPen(Qt::NoPen);
        painter.setBrush(QBrush(color));
        
        for (int x = rect.left(); x < rect.right(); x += blockSize) {
            for (int y = rect.top(); y < rect.bottom(); y += blockSize) {
                QRect block(x, y, blockSize, blockSize);
                block = block.intersected(rect);
                if (!block.isEmpty()) {
                    painter.drawRect(block);
                }
            }
        }
    }
    
    QRect boundingRect() const override { return rect; }
};

/**
 * @brief 文字元素
 */
struct TextElement : public DrawElement {
    QRect rect;
    QString text;
    QFont font;
    
    TextElement(const QRect& r, const QString& t, const QColor& c, int w, const QFont& f)
        : DrawElement(DrawTool::Text, c, w), rect(r), text(t), font(f) {}
    
    void draw(QPainter& painter) override {
        painter.setPen(QPen(color, penWidth));
        painter.setFont(font);
        painter.drawText(rect, Qt::AlignLeft | Qt::AlignTop, text);
    }
    
    QRect boundingRect() const override { return rect; }
};

/**
 * @brief [FDD-2025-03-021] 历史栈预算控制
 */
struct HistoryBudget {
    int cap;        // 最大快照数，默认20
    int current;    // 当前栈深
    int dropped;    // 被淘汰的次数

    HistoryBudget(int maxCap = 20) : cap(maxCap), current(0), dropped(0) {}
};

/**
 * @brief 截图工具类 - 类似微信截图功能
 *
 * 功能：
 * - 全屏截图
 * - 选择区域截图
 * - 矩形、圆形、箭头、画笔、马赛克、文字工具
 * - 撤销功能
 * - 保存、置顶、退出、完成
 */
class VIEW_EXPORT ScreenshotWidget : public QWidget
{
    Q_OBJECT

public:
    explicit ScreenshotWidget(QWidget *parent = nullptr);
    ~ScreenshotWidget();

    /**
     * @brief 开始截图
     */
    void startScreenshot();

    /**
     * @brief [FDD-2025-03-021][API-005] 设置历史栈上限
     * @param cap 最大快照数（最小5，默认20）
     * @return 实际生效值
     */
    int setHistoryCap(int cap);

signals:
    /**
     * @brief 截图完成信号
     * @param pixmap 截取的图片
     */
    void screenshotFinished(const QPixmap& pixmap);

    /**
     * @brief 截图取消信号
     */
    void screenshotCancelled();

protected:
    void paintEvent(QPaintEvent *event) override;
    void mousePressEvent(QMouseEvent *event) override;
    void mouseMoveEvent(QMouseEvent *event) override;
    void mouseReleaseEvent(QMouseEvent *event) override;
    void keyPressEvent(QKeyEvent *event) override;
    void resizeEvent(QResizeEvent *event) override;

private slots:
    void onToolButtonClicked();
    void onSaveButtonClicked();
    void onPinButtonClicked();
    void onExitButtonClicked();
    void onCompleteButtonClicked();
    void onUndoButtonClicked();

private:
    /**
     * @brief 初始化工具栏
     */
    void initToolbar();

    /**
     * @brief 更新遮罩层
     */
    void updateMask();

    /**
     * @brief 获取所有屏幕的截图
     */
    QPixmap captureAllScreens();

    /**
     * @brief 获取最终截图（包含所有绘图）
     */
    QPixmap getFinalScreenshot() const;

    /**
     * @brief 保存当前状态（用于撤销）
     */
    void saveState();

    /**
     * @brief 撤销上一步操作
     */
    void undo();

    /**
     * @brief 绘制所有绘图元素
     */
    void drawAllElements(QPainter& painter) const;

    /**
     * @brief 创建工具按钮
     */
    QPushButton* createToolButton(const QString& text, const QString& tooltip);

    /**
     * @brief 更新工具栏位置
     */
    void updateToolbarPosition();

    /**
     * @brief 完成文字输入（当输入框失去焦点时调用）
     */
    void finishTextInput();

    QPixmap m_fullScreenPixmap;      // 全屏截图
    QPixmap m_currentPixmap;         // 当前截图（包含绘图）
    
    // 选择区域
    QPoint m_startPoint;             // 开始点
    QPoint m_endPoint;                // 结束点
    QRect m_selectionRect;            // 选择区域
    bool m_isSelecting;               // 是否正在选择
    
    // 绘图相关
    DrawTool m_currentTool;           // 当前工具
    QColor m_currentColor;            // 当前颜色
    int m_penWidth;                   // 画笔宽度
    QList<DrawElement*> m_drawElements;  // 绘图元素列表
    QStack<QList<DrawElement*>> m_historyStack;  // 历史记录（用于撤销）
    HistoryBudget m_historyBudget;    // [FDD-2025-03-021] 历史栈预算控制
    
    // 当前绘图元素
    DrawElement* m_currentElement;    // 当前正在绘制的元素
    QPoint m_drawStartPoint;          // 绘图开始点
    QPoint m_drawEndPoint;            // 绘图结束点
    
    // 文字输入
    QTextEdit* m_textEdit;            // 文字输入框
    QRect m_textEditRect;             // 文字输入框位置
    
    // 工具栏
    QWidget* m_toolbar;               // 工具栏
    QPushButton* m_rectButton;       // 矩形按钮
    QPushButton* m_circleButton;     // 圆形按钮
    QPushButton* m_arrowButton;      // 箭头按钮
    QPushButton* m_penButton;        // 画笔按钮
    QPushButton* m_mosaicButton;     // 马赛克按钮
    QPushButton* m_textButton;       // 文字按钮
    QPushButton* m_undoButton;      // 撤销按钮
    QPushButton* m_saveButton;       // 保存按钮
    QPushButton* m_pinButton;        // 置顶按钮
    QPushButton* m_exitButton;       // 退出按钮
    QPushButton* m_completeButton;   // 完成按钮
    
    bool m_isFinished;               // 是否完成
    bool m_isPinned;                  // 是否置顶
    bool m_isDestroying;             // 是否正在析构（防止在析构过程中调用虚函数）
};

#endif // SCREENSHOTWIDGET_H
